import axios from 'axios'
import { handleApiError, handleError } from '../utils/errorHandler.jsx'

// ==========================================
// Meshy.ai API 配置
// ==========================================
const MESHY_API_KEY = import.meta.env.VITE_MESHY_API_KEY
const MESHY_API_URL = import.meta.env.VITE_MESHY_API_URL || 'https://api.meshy.ai'

// 启动时输出配置信息（用于调试）
console.log('🔧 API 配置信息:')
console.log('  - API URL:', MESHY_API_URL)
console.log('  - API Key:', MESHY_API_KEY ? `${MESHY_API_KEY.substring(0, 15)}...` : '❌ 未配置')
console.log('---')

// 创建 Meshy.ai API 客户端
const meshyClient = axios.create({
  baseURL: MESHY_API_URL,
  timeout: 180000, // 3分钟超时
  headers: {
    'Authorization': `Bearer ${MESHY_API_KEY}`,
    'Content-Type': 'application/json'
  }
})

// 创建axios实例（用于自己的后端API）
const apiClient = axios.create({
  baseURL: import.meta.env.VITE_API_BASE_URL || '/api',
  timeout: 120000,
  headers: {
    'Content-Type': 'application/json'
  }
})

// 请求拦截器
apiClient.interceptors.request.use(
  (config) => {
    // 可以在这里添加token等认证信息
    const token = localStorage.getItem('token')
    if (token) {
      config.headers.Authorization = `Bearer ${token}`
    }
    return config
  },
  (error) => {
    return Promise.reject(error)
  }
)

// 响应拦截器
apiClient.interceptors.response.use(
  (response) => {
    return response.data
  },
  (error) => {
    // 统一错误处理
    const message = error.response?.data?.message || '请求失败，请稍后重试'
    console.error('API Error:', message)
    return Promise.reject(error)
  }
)

// API方法

/**
 * 将图片转换为 Base64
 * @param {File} file - 图片文件
 * @returns {Promise<string>} Base64 编码的图片
 */
const fileToBase64 = (file) => {
  return new Promise((resolve, reject) => {
    const reader = new FileReader()
    reader.readAsDataURL(file)
    reader.onload = () => resolve(reader.result)
    reader.onerror = (error) => reject(error)
  })
}

/**
 * 使用 Meshy.ai 上传多张图片并生成3D模型（多图模式）
 * @param {File[]} imageFiles - 图片文件数组
 * @param {Object} options - 生成选项
 * @returns {Promise<Object>} 包含 taskId 的响应对象
 */
export const generate3DModelFromMultiImages = async (imageFiles, options = {}) => {
  console.log('📝 generate3DModelFromMultiImages 调用:')
  console.log('  - 图片数量:', imageFiles?.length)
  console.log('  - 生成选项:', options)
  
  try {
    // 检查 API Key
    if (!MESHY_API_KEY || MESHY_API_KEY === 'your_meshy_api_key_here') {
      console.error('❌ API Key 未配置或无效')
      throw new Error('请先配置 Meshy.ai API Key。在 .env 文件中设置 VITE_MESHY_API_KEY')
    }

    if (!imageFiles || imageFiles.length < 2) {
      throw new Error('多图模式至少需要2张图片')
    }

    if (imageFiles.length > 4) {
      throw new Error('多图模式最多支持4张图片')
    }

    console.log('🚀 使用 Meshy.ai 多图API 生成 3D 模型...')
    console.log('  - API URL:', MESHY_API_URL)

    // 将所有图片转换为 Base64
    console.log('📷 正在转换图片为 Base64...')
    const imageBase64Array = await Promise.all(
      imageFiles.map(file => fileToBase64(file))
    )
    console.log('✅ 所有图片转换完成')

    // 准备API请求参数
    const apiParams = {
      image_urls: imageBase64Array,
      enable_pbr: options.enable_pbr !== undefined ? options.enable_pbr : true,
      should_remesh: options.should_remesh !== undefined ? options.should_remesh : true,
      should_texture: options.should_texture !== undefined ? options.should_texture : true
    }
    
    // 添加高级参数（如果提供）
    if (options.topology) {
      apiParams.topology = options.topology
    }
    if (options.target_polycount && options.target_polycount !== 'auto') {
      const polycountMap = {
        'low': 5000,
        'medium': 10000,
        'high': 30000
      }
      apiParams.target_polycount = polycountMap[options.target_polycount]
    }
    if (options.texture_resolution) {
      apiParams.texture_resolution = options.texture_resolution
    }
    if (options.ai_model) {
      apiParams.ai_model = options.ai_model
    }

    // Meshy.ai API: Multi-Image to 3D
    console.log('📡 正在调用 Meshy.ai 多图API...')
    console.log('  - 端点: POST /openapi/v1/multi-image-to-3d')
    console.log('  - 请求参数:', apiParams)
    
    const response = await meshyClient.post('/openapi/v1/multi-image-to-3d', apiParams)

    console.log('📦 API 响应数据:', response.data)
    
    const taskId = response.data.result || response.data.id
    
    if (!taskId || typeof taskId !== 'string') {
      console.error('❌ 无法获取有效的 Task ID')
      console.error('  - 完整响应:', response.data)
      throw new Error('API 返回的任务ID格式无效')
    }
    
    console.log('✅ 多图任务创建成功！')
    console.log('  - Task ID:', taskId)
    console.log('  - 图片数量:', imageFiles.length)
    console.log('  - 预计时间: 3-8 分钟')
    
    return {
      taskId: taskId,
      status: 'processing',
      message: '正在使用多张图片生成 3D 模型...',
      imageCount: imageFiles.length
    }
  } catch (error) {
    console.error('❌ Meshy.ai 多图API 调用失败:', error)
    
    // 处理特定的 HTTP 错误
    if (error.response?.status === 402) {
      throw new Error('免费额度已用完，请升级到付费计划或稍后再试')
    }
    
    if (error.response?.status === 401) {
      throw new Error('API Key 无效，请检查配置')
    }
    
    if (error.response?.status === 429) {
      throw new Error('请求过于频繁，请稍后再试')
    }
    
    // 使用统一错误处理
    const errorInfo = handleApiError('/api/3d/multi-generate', error, { imageCount: imageFiles?.length })
    
    throw new Error(errorInfo.message)
  }
}

/**
 * 使用 Meshy.ai 上传单张图片并生成3D模型
 * @param {File} imageFile - 图片文件
 * @param {Object} options - 生成选项
 * @returns {Promise<Object>} 包含 taskId 的响应对象
 */
export const generate3DModel = async (imageFile, options = {}) => {
  console.log('📝 generate3DModel 调用:')
  console.log('  - 图片文件:', imageFile?.name, imageFile?.size, 'bytes')
  console.log('  - 生成选项:', options)
  
  try {
    // 检查 API Key
    if (!MESHY_API_KEY || MESHY_API_KEY === 'your_meshy_api_key_here') {
      console.error('❌ API Key 未配置或无效')
      throw new Error('请先配置 Meshy.ai API Key。在 .env 文件中设置 VITE_MESHY_API_KEY')
    }

    console.log('🚀 使用 Meshy.ai API 生成 3D 模型...')
    console.log('  - API URL:', MESHY_API_URL)
    console.log('  - API Key:', MESHY_API_KEY.substring(0, 15) + '...')

    // 将图片转换为 Base64
    console.log('📷 正在转换图片为 Base64...')
    const imageBase64 = await fileToBase64(imageFile)
    console.log('✅ 图片转换完成，大小:', imageBase64.length, '字符')
    
    // 准备API请求参数，合并默认值和用户选项
    const apiParams = {
      image_url: imageBase64, // 支持 Base64 或 URL
      enable_pbr: options.enable_pbr !== undefined ? options.enable_pbr : true,
      should_remesh: options.should_remesh !== undefined ? options.should_remesh : true,
      should_texture: options.should_texture !== undefined ? options.should_texture : true
    }
    
    // 添加高级参数（如果提供）
    if (options.topology) {
      apiParams.topology = options.topology // 'quad' or 'triangle'
    }
    if (options.target_polycount && options.target_polycount !== 'auto') {
      // 将文本转换为具体数值
      const polycountMap = {
        'low': 5000,
        'medium': 10000,
        'high': 30000
      }
      apiParams.target_polycount = polycountMap[options.target_polycount]
    }
    if (options.texture_resolution) {
      apiParams.texture_resolution = options.texture_resolution
    }
    if (options.ai_model) {
      apiParams.ai_model = options.ai_model
    }
    
    // Meshy.ai API: Image to 3D
    // 文档: https://docs.meshy.ai/api-image-to-3d
    console.log('📡 正在调用 Meshy.ai API...')
    console.log('  - 端点: POST /openapi/v1/image-to-3d')
    console.log('  - 请求参数:', apiParams)
    
    const response = await meshyClient.post('/openapi/v1/image-to-3d', apiParams)

    console.log('📦 API 响应数据:', response.data)
    
    // MeshyAI API 返回的任务ID在 result 字段中（创建时）或 id 字段中（查询时）
    const taskId = response.data.result || response.data.id
    
    if (!taskId || typeof taskId !== 'string') {
      console.error('❌ 无法获取有效的 Task ID')
      console.error('  - 完整响应:', response.data)
      throw new Error('API 返回的任务ID格式无效')
    }
    
    console.log('✅ 任务创建成功！')
    console.log('  - Task ID:', taskId)
    console.log('  - 预计时间: 2-5 分钟')
    
    return {
      taskId: taskId,
      status: 'processing',
      message: '正在使用 AI 生成 3D 模型...'
    }
  } catch (error) {
    console.error('❌ Meshy.ai API 调用失败:', error)
    
    // 处理特定的 HTTP 错误
    if (error.response?.status === 402) {
      const errorMessage = error.response?.data?.message || '需要付费才能继续使用'
      console.log('💳 付费提示:', errorMessage)
      throw new Error('免费额度已用完，请升级到付费计划或稍后再试')
    }
    
    if (error.response?.status === 401) {
      throw new Error('API Key 无效，请检查配置')
    }
    
    if (error.response?.status === 429) {
      throw new Error('请求过于频繁，请稍后再试')
    }
    
    // 使用统一错误处理
    const errorInfo = handleApiError('/api/3d/generate', error, { imageFile: imageFile?.name })
    
    // 抛出友好的错误消息
    throw new Error(errorInfo.message)
  }
}

/**
 * 处理任务状态响应（单图和多图共用）
 */
const processTaskStatus = (data, taskId) => {
  const statusMap = {
    'PENDING': 'processing',
    'IN_PROGRESS': 'processing',
    'SUCCEEDED': 'completed',
    'FAILED': 'failed',
    'EXPIRED': 'failed'
  }
  
  const status = statusMap[data.status] || 'processing'
  
  // 使用API返回的进度
  let progress = data.progress || 0
  if (!data.progress) {
    if (data.status === 'PENDING') progress = 10
    else if (data.status === 'IN_PROGRESS') progress = 50
    else if (data.status === 'SUCCEEDED') progress = 100
  }
  
  console.log(`📈 当前进度: ${progress}%`)
  
  // 如果完成
  if (status === 'completed') {
    console.log('✅ 3D 模型生成成功！')
    console.log('📥 模型下载地址:')
    console.log('  - GLB:', data.model_urls?.glb)
    
    return {
      status: 'completed',
      progress: 100,
      message: '3D 模型生成成功！',
      modelUrl: data.model_urls?.glb || data.model_urls?.fbx || null,
      thumbnailUrl: data.thumbnail_url || null,
      videoUrl: data.video_url || null,
      error: null,
      modelUrls: {
        glb: data.model_urls?.glb,
        fbx: data.model_urls?.fbx,
        usdz: data.model_urls?.usdz,
        obj: data.model_urls?.obj
      },
      taskId: taskId
    }
  }
  
  // 如果失败
  if (status === 'failed') {
    console.error('❌ 3D 模型生成失败:', data.error || '未知错误')
    return {
      status: 'failed',
      progress: 0,
      message: '生成失败',
      error: data.error || '生成失败，请重试',
      modelUrl: null
    }
  }
  
  // 处理中
  const statusMessages = {
    'PENDING': '任务已排队，等待处理...',
    'IN_PROGRESS': '正在生成 3D 模型...'
  }
  
  console.log(`⏳ 生成进度: ${progress}% (${data.status})`)
  
  return {
    status: 'processing',
    progress: progress,
    message: statusMessages[data.status] || '处理中...',
    modelUrl: null
  }
}

/**
 * 处理状态检查错误（单图和多图共用）
 */
const handleStatusCheckError = (error, taskId) => {
  console.error('❌ 检查任务状态失败:', error)
  console.error('  - 错误状态码:', error.response?.status)
  console.error('  - 错误响应:', error.response?.data)
  
  // 如果是404，任务不存在或已过期
  if (error.response?.status === 404) {
    console.error('⚠️ 任务不存在或已过期')
    return {
      status: 'failed',
      progress: 0,
      message: '任务不存在',
      error: '任务ID无效或任务已过期，请重新生成',
      modelUrl: null
    }
  }
  
  // 使用统一错误处理
  const errorInfo = handleApiError('/api/3d/status', error, { taskId })
  throw new Error(errorInfo.message)
}

/**
 * 检查多图3D模型生成状态
 * @param {string} taskId - 任务ID
 * @returns {Promise<Object>} 任务状态信息
 */
export const checkMultiImageGenerationStatus = async (taskId) => {
  console.log('🔍 检查多图生成状态, Task ID:', taskId)
  
  try {
    if (!MESHY_API_KEY || MESHY_API_KEY === 'your_meshy_api_key_here') {
      throw new Error('请先配置 Meshy.ai API Key')
    }

    const apiUrl = `/openapi/v1/multi-image-to-3d/${taskId}`
    console.log('📡 正在查询多图任务状态...')
    
    const response = await meshyClient.get(apiUrl)
    const data = response.data
    console.log('📦 多图状态响应:', data)
    
    return processTaskStatus(data, taskId)
  } catch (error) {
    return handleStatusCheckError(error, taskId)
  }
}

/**
 * 检查单图3D模型生成状态（使用 Meshy.ai）
 * @param {string} taskId - 任务ID
 * @returns {Promise<Object>} 任务状态信息
 */
export const checkGenerationStatus = async (taskId) => {
  console.log('🔍 检查单图生成状态, Task ID:', taskId)
  
  try {
    if (!MESHY_API_KEY || MESHY_API_KEY === 'your_meshy_api_key_here') {
      throw new Error('请先配置 Meshy.ai API Key')
    }

    const apiUrl = `/openapi/v1/image-to-3d/${taskId}`
    console.log('📡 正在查询单图任务状态...')
    
    const response = await meshyClient.get(apiUrl)
    const data = response.data
    console.log('📦 单图状态响应:', data)
    
    return processTaskStatus(data, taskId)
  } catch (error) {
    return handleStatusCheckError(error, taskId)
  }
}

/**
 * 获取状态对应的友好消息
 */
const getStatusMessage = (status, progress) => {
  const messages = {
    'PENDING': '任务已排队，等待处理...',
    'IN_PROGRESS': `正在生成3D模型... ${progress || 0}%`,
    'SUCCEEDED': '3D模型生成成功！',
    'FAILED': '生成失败，请重试',
    'EXPIRED': '任务已过期'
  }
  return messages[status] || '处理中...'
}

/**
 * 获取3D模型文件
 * @param {string} modelId - 模型ID
 */
export const getModelFile = async (modelId) => {
  return await apiClient.get(`/models/${modelId}`)
}

/**
 * 创建订单
 * @param {Object} orderData - 订单数据
 */
export const createOrder = async (orderData) => {
  return await apiClient.post('/orders', orderData)
}

/**
 * 上传模型到Shopify
 * @param {string} modelId - 模型ID
 * @param {Object} productData - 产品数据
 */
export const uploadToShopify = async (modelId, productData) => {
  return await apiClient.post('/shopify/upload-model', {
    modelId,
    productData
  })
}

/**
 * 发送生产订单到工厂
 * @param {Object} orderData - 订单数据
 */
export const sendToFactory = async (orderData) => {
  return await apiClient.post('/factory/submit-order', orderData)
}

/**
 * 获取支持的材质列表
 */
export const getMaterials = async () => {
  return await apiClient.get('/materials')
}

/**
 * 获取价格估算（支持多级批量折扣）
 * @param {Object} specs - 规格参数
 * @returns {Promise<Object>} 价格明细（包含单价、折扣、运费、总价等）
 */
export const getPriceEstimate = async (specs) => {
  try {
    const response = await apiClient.post('/price-estimate', specs)
    return response.data
  } catch (error) {
    console.error('获取价格估算失败:', error)
    // 失败时返回默认价格
    return {
      unitPrice: '0.00',
      basePrice: '0.00',
      discountRate: '10.0',
      discount: '0.00',
      shipping: 20,
      total: '20.00',
      savedAmount: '0.00'
    }
  }
}


export default apiClient

